package com.etime.shycourse.services.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.etime.shycourse.config.Tools;
import com.etime.shycourse.dao.CourseMapper;
import com.etime.shycourse.dao.CoursecommentMapper;
import com.etime.shycourse.dto.CourseAndCommentDto;
import com.etime.shycourse.dto.CoursecommentDto;
import com.etime.shycourse.dto.CurrentUser;
import com.etime.shycourse.filterMsg.FilterMsgData;
import com.etime.shycourse.filterMsg.FilterMsgTool;
import com.etime.shycourse.filterMsg.ReturnMsgData;
import com.etime.shycourse.pojo.Coursecomment;
import com.etime.shycourse.services.interfaces.CoursecommentServices;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author wb
 * @since 2022-03-02
 */
@Service
public class CoursecommentServiceImpl implements CoursecommentServices {
    @Autowired
    private Tools tools;

    @Autowired
    private CoursecommentMapper mapper;
    @Autowired
    private FilterMsgTool filterMsgTool;
    // 课程Mapper
    @Autowired
    private CourseMapper courseMapper;

    /**
     * 插入评论 微信端
     * 1 、Courseid commentcontent 课程id  评论内容 ，不能为空
     * 2 、commenttype	Integer		提问：2 默认   提问 1--评论 2--提问
     *
     * @param coursecomment
     * @return Integer
     * 成功返回1 失败返回0
     */
    @Override
    public Integer insetCourseComment(Coursecomment coursecomment, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user == null && coursecomment == null && user.getUser () == null) {
            return 0;
        }
        // 	Courseid commentcontent			课程id  评论内容 ，不能为空
        if (coursecomment.getCommentcontent () == null && coursecomment.getCourseid () == null) {
            return 0;
        }
        // 先对评论的类容进行过滤 判断
        // 条件构造
        FilterMsgData data = new FilterMsgData ();
        data.setOpenid (user.getUser ().getOpenid ());
        // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
        data.setScene (2);
        // 接口版本号，2.0版本为固定值2
        data.setVersion (2);
        // 评论的类容
        data.setContent (coursecomment.getCommentcontent ());
        ReturnMsgData returnMsgData = filterMsgTool.filterMsgTools (data);
        // 评论的内容过滤 成功
        if (returnMsgData.getErrcode () == 0) {
            // Label 命中标签枚举值，100 正常 ; 建议，有risky 风险、pass 通过、review 审查三种值
            if (returnMsgData.getResult ().getLabel ().equals ("100") && returnMsgData.getResult ().getSuggest ().equals ("pass")) {
                // 默认为 0
                coursecomment.setCommentscore (0);
                // 当前用户id
                coursecomment.setCommentuser (user.getUser ().getUserid ());
                //评论人姓名（使用昵称）
                //当前用户的昵称（真实姓名）
                coursecomment.setCommentusertruename (user.getUser ().getNickname ());
                //评论时间 当前时间
                coursecomment.setCommenttime (new Date ());
                //评论状态	commentstate	Integer		默认：1
                coursecomment.setCommentstate (1);
                // 评论是否展示	commentisshow	Integer		默认：0不展示
                coursecomment.setCommentisshow (0);
                // 是否加精	commentdigest	Integer		默认：0
                coursecomment.setCommentdigest (0);
                // 是否置顶	commenttop	Integer		默认0
                coursecomment.setCommenttop (0);
                //  父评论id	commentpid	Integer		评论默认：-1
                coursecomment.setCommentpid (-1);
                //评论类型	commenttype	Integer		提问：2 默认提问 1--评论 2--提问
                if (coursecomment.getCommenttype () == null) {
                    coursecomment.setCommenttype (2);
                }
                //是否回复	commentre	Integer		默认：0
                coursecomment.setCommentre (0);
                return mapper.insert (coursecomment); // 插入评论成功
            } else {
                // 评论内容 存在风险
                return -2;
            }
            // 评论过滤失败
        } else if (returnMsgData.getErrcode () == -1) {
            // -1	系统繁忙，此时请开发者稍候再试
            return -1;
        }
        return 0;
    }

    /**
     * <p>
     * 对已经插入评论 进行评价
     * 1、 Courseid commentcontent			课程id  评论内容 ，不能为空
     * 2 、commenttype	Integer		评论：1 默认    1--评论 2--提问
     *
     * @param coursecomment
     * @return Integer
     * 成功返回1 失败返回0
     */
    @Override
    public Integer insetCourseComments(Coursecomment coursecomment, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user == null && coursecomment == null && user.getUser () == null) {
            return 0;
        }
        // 	Courseid commentcontent			 评论内容 ，不能为空
        if (coursecomment.getCommentcontent () == null && coursecomment.getCourseid () == null) {
            return 0;
        }
        // 条件构造
        FilterMsgData data = new FilterMsgData ();
        data.setOpenid (user.getUser ().getOpenid ());
        // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
        data.setScene (2);
        // 接口版本号，2.0版本为固定值2
        data.setVersion (2);
        // 评论的类容
        data.setContent (coursecomment.getCommentcontent ());
        ReturnMsgData returnMsgData = filterMsgTool.filterMsgTools (data);
        // 评论的内容过滤 成功
        if (returnMsgData.getErrcode () == 0) {
            // Label 命中标签枚举值，100 正常 ; 建议，有risky 风险、pass 通过、review 审查三种值
            if (returnMsgData.getResult ().getLabel ().equals ("100") && returnMsgData.getResult ().getSuggest ().equals ("pass")) {
                // 默认为 0
                coursecomment.setCommentscore (0);
                // 当前用户id
                coursecomment.setCommentuser (user.getUser ().getUserid ());
                //评论人姓名（使用昵称）
                //当前用户的昵称（真实姓名）
                coursecomment.setCommentusertruename (user.getUser ().getNickname ());
                //评论时间 当前时间
                coursecomment.setCommenttime (new Date ());
                //评论状态	commentstate	Integer		默认：1
                coursecomment.setCommentstate (1);
                // 评论是否展示	commentisshow	Integer		默认：1展示
                coursecomment.setCommentisshow (1);
                // 是否加精	commentdigest	Integer		默认：0
                coursecomment.setCommentdigest (0);
                // 是否置顶	commenttop	Integer		默认0
                coursecomment.setCommenttop (0);
                //评论类型	commenttype	Integer		提问：1 默认提问 1--评论 2--提问
                coursecomment.setCommenttype (1);
                //是否回复	commentre	Integer		默认：0
                coursecomment.setCommentre (0);
                return mapper.insert (coursecomment);

            } else {
                // 评论内容 存在风险
                return -2;
            }
            // 评论过滤失败
        } else if (returnMsgData.getErrcode () == -1) {
            // -1	系统繁忙，此时请开发者稍候再试
            return -1;
        }
        return 0;
    }

    /**
     * 后台
     * <p>
     * 对已经插入评论 进行评价
     * 1、 Courseid commentcontent			课程id  评论内容 ，不能为空
     * 2 、commenttype	Integer	评论：1 默认   提问 1--评论 2--提问
     *
     * @param coursecomment
     * @return Integer
     * 成功返回1 失败返回0 ,-1 系统繁忙，此时请开发者稍候再试,  -2 评论内容 存在风险
     */
    @Override
    public Integer insetSysCourseComment(Coursecomment coursecomment, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user == null) {
            return 0;
        }
        // 	Courseid commentcontent	课程id  评论内容 ，不能为空
        if (coursecomment.getCommentcontent () == null ||
                coursecomment.getCourseid () == null || coursecomment.getCommentpid () == null) {
            return 0;
        }
        // 当前用户id
        coursecomment.setCommentuser (user.getUser ().getUserid ());
        // 评论人姓名 当前用户的昵称（真实姓名）+（使用昵称）
        String usertruename = user.getUser ().getUsertruename ();
        if (user.getUser ().getNickname () != null) {
            usertruename = usertruename + "(" + user.getUser ().getNickname () + ")";
        }
        coursecomment.setCommentusertruename (usertruename);
        // 评论时间 当前时间
        coursecomment.setCommenttime (new Date ());
        // 评论状态	commentstate	Integer		默认：1
        coursecomment.setCommentstate (1);
        // 评论是否展示	commentisshow	Integer		默认：1 展示
        coursecomment.setCommentisshow (1);
        // 是否加精	commentdigest	Integer		默认：0
        coursecomment.setCommentdigest (0);
        // 是否置顶	commenttop	Integer		默认1
        coursecomment.setCommenttop (1);
        // 评论类型	commenttype	Integer		提问：1--评论
        coursecomment.setCommenttype (1);
        // 是否回复	commentre	Integer		默认：1
        coursecomment.setCommentre (0);
        // 设置头像
        coursecomment.setUserimgurl (user.getUser ().getShowpic ());
        int insert = mapper.insert (coursecomment);
        // 判断是否回复成功
        int i = 0; //修改该课程 为已回的返回值
        if (insert > 0) {
            //问题老师的回复；
            //0--未回复
            //1--已回复
            if (coursecomment.getCommentre () != null && coursecomment.getCommentre () == 0) {
                Coursecomment c = new Coursecomment ();
                // 设置修改评论数据的 id
                c.setCommentid (coursecomment.getCommentpid ());
                // 设置为教师已 回复 问题老师的回复；0--未回复 1--已回复
                c.setCommentre (1);
                i = mapper.updateById (c);//修改该课程 为已回复
            }
        }
        if (i > 0) {
            return insert;
        }
        return 0;
    }


    /**
     * wx & 支招模块
     * <p>
     * 根据评论d 查询评论或提问的评论
     *
     * @param CommentID
     * @return List<Coursecomment>
     **/
    @Override
    public List<Coursecomment> selectCommentListById(Integer CommentID) {
        return mapper.selectList (new QueryWrapper<Coursecomment> ().eq ("commentpid", CommentID));
    }

    /**
     * 查询 评论
     *
     * @return List<Coursecomment>
     **/
    @Override
    public List<Coursecomment> selectCommentList(Integer CourseId) {
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<> ();
        // 评论是否展示 判断
        wrapper.eq ("commentisshow", 1);
        // 判断是否是 评论  1
        wrapper.eq ("commenttype", 1);
        // 父评论id，课程评论=-1
        wrapper.eq ("commentpid", -1);
        // 1）置顶的评论放在最上面；
        wrapper.orderByDesc ("commenttop");
        // 2）置顶之下放置“加精”的评论
        wrapper.orderByDesc ("commentdigest");
        // 3）普通评论以时间倒序排列
        wrapper.orderByDesc ("commenttime");
        // 4）每个课程的评论只显示最多10条评论，如
        wrapper.last ("limit 10");
        return mapper.selectList (wrapper);
    }

    /**
     * 评论，提问后台管理模块
     * <p>
     * 根据课程id 查询 评论和提问
     *
     * @param coursecomment
     * @return List<Coursecomment>
     **/
    @Override
    public List<Coursecomment> selectSysCommentList(Coursecomment coursecomment) {
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<> ();
        //  根据课程id查询
        if (coursecomment.getCourseid () != null) {
            wrapper.eq ("courseid", coursecomment.getCourseid ());
        }
        // 根据 评论类型 1--评论 2--提问
        if (coursecomment.getCommenttype () != null) {
            wrapper.eq ("commenttype", coursecomment.getCommenttype ());
        }
        // 根据 commenttime 创建时间排序 降序
        wrapper.orderByDesc ("commenttime");
        return mapper.selectList (wrapper);
    }

    @Override
    public Page<Coursecomment> selectSysCommentPage(Coursecomment coursecomment, Long pagenum, Long pagesize) {
        /**
         * 当前端没有传分页数据时 就使用 page默认的值
         * pagesize = 1L
         * size = 10L;
         * */
        Page<Coursecomment> page;
        if (pagenum != null & pagesize != null) {
            page = new Page<> (pagenum, pagesize);
        } else {
            page = new Page<> ();
        }
        //条件构造
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<> ();
        // 根据课程id 进查看评论
        if (coursecomment.getCourseid () != null) {
            wrapper.eq ("courseid", coursecomment.getCourseid ());
        }
        //查询 是评论 还是提问 commenttype
        if (coursecomment.getCommenttype () != null) {
            wrapper.eq ("commenttype", coursecomment.getCommenttype ());
        }
        // 父id = -1
        wrapper.eq ("commentpid", -1);
        // 是否回复
        wrapper.orderByAsc ("commentre");
        // 时间 降序
        wrapper.orderByDesc ("commenttop", "commentdigest", "commenttime");
        return mapper.selectPage (page, wrapper);
    }


    @Override
    public Page<CoursecommentDto> selectSysCommentPages(CoursecommentDto coursecomment, Long pagenum, Long pagesize) {
        /**
         * 当前端没有传分页数据时 就使用 page默认的值
         * pagesize = 1L
         * size = 10L;
         * */
        Page<CoursecommentDto> page;
        if (pagenum != null & pagesize != null) {
            page = new Page<> (pagenum, pagesize);
        } else {
            page = new Page<> ();
        }
        // 查询评论内容 课程信息
        // 条件 根据课程 id ，模糊搜索课程名 ， 评论类型， 是否回复，评论状态，评论时间区间
        // 创建时间降序 未回复 是否置顶 是否加精

        return mapper.selectSysCommentPages (coursecomment, page);
    }

    /**
     * 评论，提问后台管理模块
     * <p>
     * 根据评论id wx+查询评论或提问的评论
     *
     * @param commentId
     * @return List<Coursecomment>
     **/
    @Override
    public Page<Coursecomment> selectSysCommentByID(Integer commentId, Long pagenum, Long pagesize) {
        Page<Coursecomment> page;
        if (pagenum != null & pagesize != null) {
            page = new Page<> (pagenum, pagesize);
        } else {
            page = new Page<> ();
        }
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<Coursecomment> ();
        wrapper.eq ("commentpid", commentId);
        // 时间 降序
        wrapper.orderByDesc ("commenttop", "commenttime");
        return mapper.selectPage (page, wrapper);
    }

    @Override
    public List<Coursecomment> selectSysCommentByID(Integer commentId) {
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<> ();
        wrapper.eq ("commentpid", commentId);
        // 时间 降序
        wrapper.orderByDesc ("commenttop", "commenttime");
        return mapper.selectList (wrapper);
    }

    /**
     * 我的提问
     * <p>
     * 根据用户的id 查询 我的提问列表
     *
     * @param token
     * @return List<Coursecomment>
     **/
    @Override
    public List<CoursecommentDto> selectMyQuestionsCommentList(String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user != null && user.getUser () != null) {
            return mapper.selectMyQuestionsCommentList (user.getUser ().getUserid ());
        }
        return null;
    }

    /**
     * 我的评论
     * <p>
     * 根据用户的id 查询 我的提问列表
     *
     * @param token
     * @return List<Coursecomment>
     **/
    @Override
    public List<CoursecommentDto> selectMyCommentList(String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user != null || user.getUser () != null) {
            return mapper.selectMyCommentList (user.getUser ().getUserid ());
        }
        return null;
    }

    /**
     * 统计评论条数
     * 根据课程id
     *
     * @param CourseId
     * @return Int
     */
    @Override
    public Integer countComment(Integer CourseId) {
        return mapper.countComment (CourseId);
    }

    /**
     * 统计提问条数
     * 根据课程id
     *
     * @param CourseId
     * @return Int
     */
    @Override
    public Integer countQuestions(Integer CourseId) {
        // 条件 课程ID 评论类型 2->提问  commentpid -1 ->父评论id
        return mapper.selectCount (new QueryWrapper<Coursecomment> ().eq ("courseid", CourseId).eq ("commenttype", 2).eq ("commentpid", -1));
    }

    /**
     * 后台管理模块
     * <p>
     * updateCommentById
     * 根据课程评论的id  进行修改 评论的置顶，加精
     *
     * @param coursecomment
     * @return int
     */
    @Override
    public Integer updateCommentById(Coursecomment coursecomment) {
        //据课程评论的id 进行修改 评论的置顶，加精
        return mapper.updateById (coursecomment);
    }

    /**
     * 后台 管理课程 /----修改
     * 统计评论的条数 ，数据
     *
     * @param CourseId 课程id
     * @return CourseAndCommentDto
     */
    @Override
    public CourseAndCommentDto selectCourseAndCommentDtoByIds(Integer CourseId) {
        return mapper.selectCourseAndCommentDtoByIds (CourseId);
    }
}
